//package com.pony.iphone.task;
//
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
//import com.pony.iphone.dto.StableAnswerUpdate;
//import com.pony.iphone.entity.Question;
//import com.pony.iphone.entity.QuestionStable;
//import com.pony.iphone.mapper.QuestionStableMapper;
//import com.pony.iphone.service.QuestionService;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.scheduling.annotation.Scheduled;
//import org.springframework.stereotype.Component;
//import org.springframework.transaction.annotation.Transactional;
//
//import java.util.*;
//import java.util.function.Function;
//import java.util.stream.Collectors;
//
///**
// * 问题的定时任务
// * @author pony
// * @create 2025-11-05 16:39
// */
//@Slf4j
//@Component
//public class QuestionTask {
//    // 定时任务，启动时间
//    @Value("${app.scheduled.clean-task-cron}")
//    private String cleanTaskCron;
//    // 稳定答案的阈值
//    @Value("${app.scheduled.stable-threshold:0.8}")
//    private double stableThreshold;
//
//    @Autowired
//    private QuestionService questionService;
//
//    @Autowired
//    private QuestionStableMapper questionStableMapper;
//
//    /**
//     * 更新稳定问题 - 批量优化版本
//     */
//    @Scheduled(cron = "${app.scheduled.clean-task-cron}")
//    @Transactional
//    public void updateStableQuestionByCron() {
//        log.info("开始更新稳定答案表数据");
//        try {
//            // 1、查询出所有问题
//            List<Question> questionList = questionService.list();
//            log.info("共查询到 {} 个问题需要处理", questionList.size());
//
//            // 2、批量处理：先收集所有需要更新的数据，再批量操作
//            List<StableAnswerUpdate> updates = processQuestionsInBatch(questionList);
//
//            // 3、批量执行数据库操作
//            if (!updates.isEmpty()) {
//                executeBatchUpdates(updates);
//                log.info("稳定答案更新完成: 成功更新 {} 个问题", updates.size());
//            } else {
//                log.info("没有需要更新的稳定答案");
//            }
//
//        } catch (Exception e) {
//            log.error("更新稳定答案表数据失败", e);
//            throw new RuntimeException("更新稳定答案失败", e);
//        }
//    }
//
//    /**
//     * 批量处理问题，收集需要更新的数据
//     */
//    private List<StableAnswerUpdate> processQuestionsInBatch(List<Question> questionList) {
//        // 收集所有问题ID
//        List<Long> questionIds = questionList.stream()
//                .map(Question::getId)
//                .collect(Collectors.toList());
//
//        // 批量查询当前稳定版本
//        Map<Long, QuestionStable> currentStableMap = batchGetCurrentStableVersions(questionIds);
//
//        List<StableAnswerUpdate> updates = new ArrayList<>();
//
//        for (Question question : questionList) {
//            StableAnswerUpdate update = processSingleQuestion(question, currentStableMap);
//            if (update != null) {
//                updates.add(update);
//            }
//        }
//
//        return updates;
//    }
//
//    /**
//     * 批量查询当前稳定版本
//     */
//    private Map<Long, QuestionStable> batchGetCurrentStableVersions(List<Long> questionIds) {
//        if (questionIds.isEmpty()) {
//            return new HashMap<>();
//        }
//
//        // 使用 IN 查询批量获取
//        List<QuestionStable> currentStables = questionStableMapper.selectList(
//                new LambdaQueryWrapper<QuestionStable>()
//                        .in(QuestionStable::getQuestionId, questionIds)
//                        .eq(QuestionStable::getIsCurrent, 1)
//        );
//
//        return currentStables.stream()
//                .collect(Collectors.toMap(QuestionStable::getQuestionId, Function.identity()));
//    }
//
//    /**
//     * 处理单个问题，返回更新信息（不操作数据库）
//     */
//    private StableAnswerUpdate processSingleQuestion(Question question, Map<Long, QuestionStable> currentStableMap) {
//        // 检查问题答案是否有效
//        if (question.getAnswer() == null || question.getAnswer().isEmpty()) {
//            log.debug("问题ID: {} 的答案为空，跳过处理", question.getId());
//            return null;
//        }
//
//        // 计算每个选项的概率
//        Map<String, Double> probabilityMap = calculateAnswerProbability(question);
//
//        // 使用配置的阈值
//        Optional<Map.Entry<String, Double>> stableAnswerEntry = probabilityMap.entrySet()
//                .stream()
//                .filter(entry -> entry.getValue() >= stableThreshold)
//                .findFirst();
//
//        if (stableAnswerEntry.isPresent()) {
//            String stableAnswer = stableAnswerEntry.get().getKey();
//            double probability = stableAnswerEntry.get().getValue();
//
//            // 检查是否需要更新（答案有变化）
//            QuestionStable currentStable = currentStableMap.get(question.getId());
//            if (currentStable != null && stableAnswer.equals(currentStable.getStableAnswer())) {
//                log.debug("问题ID: {} 的稳定答案未变化，跳过更新", question.getId());
//                return null;
//            }
//
//            log.info("问题ID: {} 找到稳定答案: {} (概率: {}%, 阈值: {}%)",
//                    question.getId(),
//                    stableAnswer,
//                    String.format("%.2f", probability * 100),
//                    String.format("%.0f", stableThreshold * 100));
//
//            return new StableAnswerUpdate(question.getId(), stableAnswer, currentStable);
//        } else {
//            log.debug("问题ID: {} 没有找到概率超过{}的稳定答案，最高概率: {}",
//                    question.getId(),
//                    String.format("%.0f%%", stableThreshold * 100),
//                    String.format("%.2f%%", getMaxProbability(probabilityMap) * 100));
//            return null;
//        }
//    }
//
//    /**
//     * 批量执行数据库更新
//     */
//    private void executeBatchUpdates(List<StableAnswerUpdate> updates) {
//        // 1. 批量更新旧版本（标记为非当前）
//        List<QuestionStable> versionsToUpdate = updates.stream()
//                .map(StableAnswerUpdate::getCurrentStable)
//                .filter(Objects::nonNull)
//                .toList();
//
//        if (!versionsToUpdate.isEmpty()) {
//            for (QuestionStable stable : versionsToUpdate) {
//                stable.setIsCurrent(0);
//                questionStableMapper.updateById(stable);
//            }
//            log.info("批量更新了 {} 个旧版本状态", versionsToUpdate.size());
//        }
//
//        // 2. 批量插入新版本
//        List<QuestionStable> versionsToInsert = new ArrayList<>();
//        for (StableAnswerUpdate update : updates) {
//            Long nextVersion = getNextVersion(update.getQuestionId());
//
//            QuestionStable newStable = new QuestionStable();
//            newStable.setQuestionId(update.getQuestionId());
//            newStable.setStableAnswer(update.getStableAnswer());
//            newStable.setIsCurrent(1);
//            newStable.setVersion(nextVersion);
//
//            versionsToInsert.add(newStable);
//        }
//
//        if (!versionsToInsert.isEmpty()) {
//            // 使用 MyBatis-Plus 的批量插入
//            for (QuestionStable stable : versionsToInsert) {
//                questionStableMapper.insert(stable);
//            }
//            log.info("批量插入了 {} 个新稳定版本", versionsToInsert.size());
//        }
//    }
//
//    /**
//     * 获取下一个版本号（优化版本，批量查询）
//     */
//    private Long getNextVersion(Long questionId) {
//        // 这里可以进一步优化为批量查询版本号
//        Long maxVersion = questionStableMapper.selectMaxVersionByQuestionId(questionId);
//        return (maxVersion == null) ? 1L : maxVersion + 1;
//    }
//    /**
//     * 计算每个答案选项的概率
//     * 根据你的权重逻辑：分数越高，权重越小，概率越小
//     */
//    private Map<String, Double> calculateAnswerProbability(Question question) {
//        Map<String, Long> answerScores = question.getAnswer();
//
//        // 1. 找出最大分数
//        long maxScore = answerScores.values().stream()
//                .mapToLong(Long::longValue)
//                .max()
//                .orElse(0L);
//
//        // 2. 计算每个选项的权重（分数越高，权重越小）
//        Map<String, Long> weights = new HashMap<>();
//        long totalWeight = 0L;
//
//        for (Map.Entry<String, Long> entry : answerScores.entrySet()) {
//            long weight = maxScore + 1 - entry.getValue();
//            weights.put(entry.getKey(), weight);
//            totalWeight += weight;
//        }
//
//        // 3. 计算每个选项的概率
//        Map<String, Double> probabilityMap = new HashMap<>();
//        for (Map.Entry<String, Long> entry : weights.entrySet()) {
//            double probability = totalWeight == 0 ? 0.0 : (double) entry.getValue() / totalWeight;
//            probabilityMap.put(entry.getKey(), probability);
//        }
//
//        log.debug("问题ID: {} 答案概率计算: {}", question.getId(), probabilityMap);
//        return probabilityMap;
//    }
//
//    /**
//     * 获取最大概率值
//     */
//    private double getMaxProbability(Map<String, Double> probabilityMap) {
//        return probabilityMap.values().stream()
//                .mapToDouble(Double::doubleValue)
//                .max()
//                .orElse(0.0);
//    }
//}
